import axios from "axios";
import { ElMessage } from "element-plus";
import router from "@/router";
import { useTokenStore } from "@/store/token";

const request = axios.create({
    // baseURL: getConfig('API_BASE_URL'), // 不经过前端正向代理
    baseURL: '/api',
    timeout: 5000,
})

// request拦截器
request.interceptors.request.use(config => {
    // 添加token
    // const token =  localStorage.getItem('token' || '{}');
    // if (token) {
    //     config.headers['Authorization'] = token;
    // }
    // 从pinia获取token
    const tokenStore = useTokenStore();
    if (tokenStore.token) {
        config.headers['Authorization'] = tokenStore.token;
    }
    
    // 处理特殊 Content-Type
    if (config.headers['Content-Type'] === 'multipart/form-data') {
      config.transformRequest = [data => data];
    }
    return config
}, error => {
    return Promise.reject(error)
})


// response 拦截器
request.interceptors.response.use(response => {
    let  res = response.data;
    // 后端返回blob文件
    if(res instanceof Blob) {
        return response
    }
    if(typeof res === 'string') {
        res = res ? JSON.parse(res) : res
    }
    // 如果返回401代表jwt验证未通过，这里的情况是给了token验证时有问题，产生了自定义错误，其设置为了401
    if (res.code === '401') {
        ElMessage.error(res.msg)
        router.push('/login')
        return
    }
    // 判断业务状态码
    if (res.code === '200') {
        return res.data
    } else {
        ElMessage.error(res.msg? res.msg : "服务异常")
        return Promise.reject(new Error(res.message || '请求失败'));
    }
}, error => {
    if (error instanceof TypeError) {
        // ElMessage.error(error.message)
        ElMessage.error("请求参数类型错误")
    } else if(error.code === 'ERR_NETWORK') {
        ElMessage.error("系统异常，可能是无法找到后端")
        router.push('/login')
    } else if(error.response.status === 401) {
        // 如果请求的响应状态码为401，代表未登录，跳转到登录页
        ElMessage.error('请先登录！')
        router.push('/login')
    } else if(error.response.status === 404) {
        ElMessage.error("系统异常，未找到请求接口")
    } else if(error.response.status === 405) {
        ElMessage.error("请求的方法不被允许")
    } else if (error.response.status === 500) {
        ElMessage.error("系统异常，请查看后端控制台报错")
    } else {
        console.log(error.message);
    }
    return Promise.reject(error)
})

export default request

// 下面是deepseek生成的request.js
// import axios from 'axios';
// import { message } from 'antd'; // 根据UI库调整，或使用 console

// // 创建 Axios 实例
// const service = axios.create({
//   baseURL: process.env.REACT_APP_BASE_API, // 从环境变量读取
//   timeout: 15000, // 请求超时时间
//   withCredentials: true, // 跨域请求时发送 cookies
//   headers: { 'Content-Type': 'application/json;charset=utf-8' }
// });

// // 请求队列（用于取消请求）
// const pendingRequests = new Map();

// /**
//  * 生成请求唯一标识
//  * @param {object} config 请求配置
//  * @returns {string} 唯一标识
//  */
// const generateRequestKey = (config) => {
//   const { method, url, params, data } = config;
//   return [method, url, JSON.stringify(params), JSON.stringify(data)].join('&');
// };

// /**
//  * 添加请求到队列
//  * @param {object} config 请求配置
//  */
// const addPendingRequest = (config) => {
//   const requestKey = generateRequestKey(config);
//   config.cancelToken = config.cancelToken || new axios.CancelToken(cancel => {
//     if (!pendingRequests.has(requestKey)) {
//       pendingRequests.set(requestKey, cancel);
//     }
//   });
// };

// /**
//  * 从队列移除请求
//  * @param {object} config 请求配置
//  */
// const removePendingRequest = (config) => {
//   const requestKey = generateRequestKey(config);
//   if (pendingRequests.has(requestKey)) {
//     const cancel = pendingRequests.get(requestKey);
//     cancel(requestKey);
//     pendingRequests.delete(requestKey);
//   }
// };

// // 请求拦截器
// service.interceptors.request.use(
//   config => {
//     // 发送前移除重复请求
//     removePendingRequest(config);
//     // 将当前请求添加到队列
//     addPendingRequest(config);
    
//     // 添加认证 token
//     const token = localStorage.getItem('access_token');
//     if (token) {
//       config.headers.Authorization = `Bearer ${token}`;
//     }
    
//     // 处理特殊 Content-Type
//     if (config.headers['Content-Type'] === 'multipart/form-data') {
//       config.transformRequest = [data => data];
//     }
    
//     return config;
//   },
//   error => {
//     return Promise.reject(error);
//   }
// );

// // 响应拦截器
// service.interceptors.response.use(
//   response => {
//     // 请求完成后移除队列
//     removePendingRequest(response.config);
    
//     const { data } = response;
//     // 根据业务状态码处理
//     if (data.code !== 0) {
//       message.error(data.msg || '业务错误');
//       return Promise.reject(new Error(data.msg || 'Error'));
//     }
    
//     return data;
//   },
//   error => {
//     // 请求完成移除队列
//     error.config && removePendingRequest(error.config);
    
//     // 处理取消请求的特定错误（不提示）
//     if (axios.isCancel(error)) {
//       return Promise.reject(new Error('请求已取消'));
//     }
    
//     // 错误处理
//     let errorMessage = '请求错误';
    
//     if (error.response) {
//       // HTTP 状态码错误处理
//       const { status, data } = error.response;
      
//       switch (status) {
//         case 400:
//           errorMessage = data?.msg || '请求参数错误';
//           break;
//         case 401:
//           errorMessage = '身份认证失败';
//           // 跳转到登录页
//           window.location.href = '/login';
//           break;
//         case 403:
//           errorMessage = '没有操作权限';
//           break;
//         case 404:
//           errorMessage = '资源不存在';
//           break;
//         case 500:
//           errorMessage = data?.msg || '服务器内部错误';
//           break;
//         case 503:
//           errorMessage = '服务不可用';
//           break;
//         default:
//           errorMessage = `连接错误 ${status}`;
//       }
//     } else if (error.request) {
//       // 请求未收到响应
//       errorMessage = '服务器未响应';
//     } else {
//       // 其他错误
//       errorMessage = error.message;
//     }
    
//     message.error(errorMessage);
//     return Promise.reject(error);
//   }
// );

// /**
//  * 核心请求方法
//  * @param {object} options 请求配置
//  * @returns {Promise} 请求Promise
//  */
// const request = (options) => {
//   // 默认配置
//   const defaultOptions = {
//     retryCount: 0, // 重试次数
//     retryDelay: 1000, // 重试延迟
//     cancelDuplicate: true // 是否取消重复请求
//   };
  
//   const mergedOptions = { ...defaultOptions, ...options };
  
//   // 创建取消令牌
//   if (mergedOptions.cancelDuplicate) {
//     mergedOptions.cancelToken = new axios.CancelToken(cancel => {
//       mergedOptions.cancel = cancel;
//     });
//   }
  
//   // 重试逻辑
//   return new Promise((resolve, reject) => {
//     const executeRequest = (attempt = 0) => {
//       service(mergedOptions)
//         .then(resolve)
//         .catch(error => {
//           if (attempt < mergedOptions.retryCount && !axios.isCancel(error)) {
//             setTimeout(() => executeRequest(attempt + 1), mergedOptions.retryDelay);
//           } else {
//             reject(error);
//           }
//         });
//     };
    
//     executeRequest();
//   });
// };

// // 快捷方法
// const get = (url, params, options) => {
//   return request({ method: 'GET', url, params, ...options });
// };

// const post = (url, data, options) => {
//   return request({ method: 'POST', url, data, ...options });
// };

// const put = (url, data, options) => {
//   return request({ method: 'PUT', url, data, ...options });
// };

// const del = (url, params, options) => {
//   return request({ method: 'DELETE', url, params, ...options });
// };

// // 文件上传方法
// const upload = (url, file, options) => {
//   const formData = new FormData();
//   formData.append('file', file);
  
//   return post(url, formData, {
//     headers: { 'Content-Type': 'multipart/form-data' },
//     ...options
//   });
// };

// // 取消所有请求
// const cancelAllRequests = () => {
//   pendingRequests.forEach(cancel => cancel('取消所有请求'));
//   pendingRequests.clear();
// };

// export default {
//   request,
//   get,
//   post,
//   put,
//   delete: del,
//   upload,
//   cancelAllRequests
// };